// 回合状态枚举
export enum TurnStatus {
  Draft = 'draft',        // 草稿状态
  Sent = 'sent',          // 已发送
  Success = 'success',    // 成功
  Failed = 'failed',      // 失败
  Cancelled = 'cancelled', // 已取消
}

// 节点类型枚举
export enum NodeType {
  RawResponse = 'RAW_RESPONSE',           // 原始响应节点
  SuggestedQuestions = 'SUGGESTED_QUESTIONS', // 建议问题节点
  MainTextFinished = 'MAIN_TEXT_FINISHED',    // 主文本完成节点
  ToolUse = 'TOOL_USE',                   // 工具使用节点
  ToolUseStart = 'TOOL_USE_START',        // 工具使用开始节点
  AgentMemory = 'AGENT_MEMORY',           // 代理内存节点
  Thinking = 'THINKING',                  // 思考节点
}

// 基础节点接口
export interface BaseNode {
  type: NodeType;        // 节点类型
  ts: number;            // 时间戳（毫秒级epoch时间）
  requestId: string;     // 请求ID，用于将节点关联到回合/请求
}

// 原始响应节点接口
export interface RawResponseNode extends BaseNode {
  type: NodeType.RawResponse;
  text: string;          // 令牌块或最终合并的文本
}

// 建议问题节点接口
export interface SuggestedQuestionsNode extends BaseNode {
  type: NodeType.SuggestedQuestions;
  questions: string[];   // 问题列表
}

// 主文本完成节点接口
export interface MainTextFinishedNode extends BaseNode {
  type: NodeType.MainTextFinished;
}

// 工具使用开始节点接口
export interface ToolUseStartNode extends BaseNode {
  type: NodeType.ToolUseStart;
  tool: string;          // 工具名称
  input: unknown;        // 工具输入参数
}

// 工具使用节点接口
export interface ToolUseNode extends BaseNode {
  type: NodeType.ToolUse;
  tool: string;          // 工具名称
  input: unknown;        // 工具输入参数
  result?: unknown;      // 工具执行结果（可选）
  error?: string;        // 错误信息（可选）
}

// 代理内存节点接口
export interface AgentMemoryNode extends BaseNode {
  type: NodeType.AgentMemory;
  memoryId: string;      // 内存ID
  content: string;       // 内存内容
}

// 思考节点接口
export interface ThinkingNode extends BaseNode {
  type: NodeType.Thinking;
  text?: string;         // 思考令牌（可选）
}

// 结构化节点类型联合
export type StructuredNode =
  | RawResponseNode
  | SuggestedQuestionsNode
  | MainTextFinishedNode
  | ToolUseStartNode
  | ToolUseNode
  | AgentMemoryNode
  | ThinkingNode;

// 回合接口
export interface Turn {
  id: string;              // 回合ID
  requestId: string;       // 请求ID
  status: TurnStatus;      // 回合状态
  requestMessage: string;  // 请求消息
  nodes: StructuredNode[]; // 节点列表
}

// 发送请求接口
export interface SendRequest {
  requestMessage: string;  // 请求消息
  modelId?: string;        // 模型ID（可选）
  context?: unknown;       // 上下文信息（可选）
}

// 会话配置接口
export interface SessionConfig {
  allowAutoTools?: boolean; // 是否允许自动工具调用（可选）
}

// 聊天模式枚举 - 基于 Augment Code 分析
export enum ChatMode {
  CHAT = 'CHAT',                    // 普通聊天模式
  AGENT = 'AGENT',                  // Agent 模式
  REMOTE_AGENT = 'REMOTE_AGENT',    // 远程 Agent 模式
  MEMORIES = 'MEMORIES',            // 记忆模式
}

// 聊天消息接口
export interface ChatMessage {
  id?: string;                      // 消息ID（可选，发送时可能未设置）
  content: string;                  // 消息内容
  role: 'user' | 'assistant' | 'system'; // 消息角色
  timestamp?: Date;                 // 时间戳（可选）
  metadata?: Record<string, any>;   // 元数据（可选）
}

// 聊天响应接口
export interface ChatResponse {
  id: string;                       // 响应ID
  content: string;                  // 响应内容
  role: 'assistant';                // 响应角色（固定为assistant）
  timestamp: Date;                  // 时间戳
  state: TurnStatus;                // 响应状态
  metadata?: Record<string, any>;   // 元数据（可选）
}

// 流式响应接口
export interface StreamingResponse {
  type: 'node' | 'state' | 'error'; // 响应类型
  node?: StructuredOutputNode;      // 结构化输出节点（当type为'node'时）
  state?: TurnStatus;               // 状态更新（当type为'state'时）
  error?: string;                   // 错误信息（当type为'error'时）
}

// 结构化输出节点接口
export interface StructuredOutputNode {
  type: NodeType;                   // 节点类型
  content: string;                  // 节点内容
  metadata: Record<string, any>;    // 节点元数据
}

// 工具类型枚举 - 基于 Augment Code 工具集
export enum ToolType {
  READ_FILE = 'read-file',
  SAVE_FILE = 'save-file',
  EDIT_FILE = 'edit-file',
  STR_REPLACE_EDITOR = 'str-replace-editor',
  LAUNCH_PROCESS = 'launch-process',
  KILL_PROCESS = 'kill-process',
  READ_PROCESS = 'read-process',
  WRITE_PROCESS = 'write-process',
  OPEN_BROWSER = 'open-browser',
  WEB_FETCH = 'web-fetch',
  REMEMBER = 'remember',
  MEMORY_RETRIEVAL = 'memory-retrieval',
  DIAGNOSTICS = 'diagnostics',
}

// 代码上下文接口
export interface CodeContext {
  currentFile?: string;           // 当前文件路径
  selectedCode?: string;          // 选中的代码
  workspaceFiles: string[];       // 工作区文件列表
  gitBranch?: string;            // Git 分支
  gitCommit?: string;            // Git 提交哈希
  recentChanges?: string[];      // 最近的更改
}

// 代理记忆接口
export interface AgentMemory {
  id: string;                    // 记忆ID
  content: string;               // 记忆内容
  scope?: string;                // 作用域
  source: string;                // 来源
  timestamp: number;             // 时间戳
  state: 'pending' | 'accepted' | 'rejected'; // 状态
  version?: string;              // 版本
}

// 提示词配置接口
export interface PromptConfig {
  systemPrompt?: string;          // 系统提示词
  includeCodeContext?: boolean;   // 是否包含代码上下文
  includeMemories?: boolean;      // 是否包含记忆
  includeToolHistory?: boolean;   // 是否包含工具历史
  maxContextLength?: number;      // 最大上下文长度
  temperature?: number;          // 温度参数
  maxTokens?: number;           // 最大令牌数
}

// 增强的提示词配置接口
export interface EnhancedPromptConfig extends PromptConfig {
  templateId?: string;           // 模板ID
  contextPriority?: ContextPriority; // 上下文优先级配置
  memoryRetrievalConfig?: MemoryRetrievalConfig; // 记忆检索配置
  toolAnalysisConfig?: ToolAnalysisConfig; // 工具分析配置
  optimizationConfig?: OptimizationConfig; // 优化配置
}

// 提示词模板接口
export interface PromptTemplate {
  id: string;                    // 模板唯一标识
  name: string;                  // 模板名称
  description?: string;          // 模板描述
  mode: ChatMode;                // 适用的聊天模式
  systemPrompt: string;          // 系统提示词模板
  sections: PromptSection[];     // 提示词段落配置
  variables?: Record<string, PromptVariable>; // 模板变量定义
  metadata?: Record<string, any>; // 元数据
}

// 提示词段落配置
export interface PromptSection {
  id: string;                    // 段落ID
  name: string;                  // 段落名称
  type: PromptSectionType;       // 段落类型
  template: string;              // 段落模板
  enabled: boolean;              // 是否启用
  priority: number;              // 优先级 (0-100)
  conditions?: PromptCondition[]; // 启用条件
  maxLength?: number;            // 最大长度限制
}

// 提示词段落类型
export enum PromptSectionType {
  SYSTEM = 'system',             // 系统提示
  CODE_CONTEXT = 'code_context', // 代码上下文
  MEMORIES = 'memories',         // 记忆
  TOOL_HISTORY = 'tool_history', // 工具历史
  CONVERSATION = 'conversation', // 对话历史
  GUIDELINES = 'guidelines',     // 指导原则
  RULES = 'rules',              // 规则
  CUSTOM = 'custom'             // 自定义
}

// 提示词变量定义
export interface PromptVariable {
  name: string;                  // 变量名
  type: 'string' | 'number' | 'boolean' | 'array' | 'object';
  description?: string;          // 变量描述
  defaultValue?: any;            // 默认值
  required?: boolean;            // 是否必需
  validation?: PromptVariableValidation; // 验证规则
}

// 变量验证规则
export interface PromptVariableValidation {
  minLength?: number;            // 最小长度
  maxLength?: number;            // 最大长度
  pattern?: string;              // 正则表达式
  enum?: any[];                  // 枚举值
}

// 提示词条件
export interface PromptCondition {
  type: 'variable' | 'context' | 'mode' | 'custom';
  field: string;                 // 条件字段
  operator: 'eq' | 'ne' | 'gt' | 'lt' | 'contains' | 'exists';
  value?: any;                   // 比较值
  customCheck?: (context: any) => boolean; // 自定义检查函数
}

// 上下文优先级配置
export interface ContextPriority {
  codeContext: number;           // 代码上下文权重 (0-1)
  memories: number;              // 记忆权重 (0-1)
  toolHistory: number;           // 工具历史权重 (0-1)
  conversationHistory: number;   // 对话历史权重 (0-1)
  dynamicAdjustment: boolean;    // 是否动态调整权重
}

// 记忆检索配置
export interface MemoryRetrievalConfig {
  maxMemories: number;           // 最大记忆数量
  semanticThreshold: number;     // 语义相似度阈值 (0-1)
  timeDecayFactor: number;       // 时间衰减因子 (0-1)
  scopeFiltering: boolean;       // 是否按作用域过滤
  relevanceScoring: boolean;     // 是否使用相关性评分
}

// 工具分析配置
export interface ToolAnalysisConfig {
  maxToolHistory: number;        // 最大工具历史数量
  patternAnalysis: boolean;      // 是否进行模式分析
  successRateWeighting: boolean; // 是否按成功率加权
  contextualGrouping: boolean;   // 是否按上下文分组
}

// 优化配置
export interface OptimizationConfig {
  compressionStrategy: 'truncate' | 'summarize' | 'prioritize'; // 压缩策略
  preserveStructure: boolean;    // 是否保持结构
  adaptiveLength: boolean;       // 是否自适应长度
  qualityThreshold: number;      // 质量阈值 (0-1)
}

// 对话轮次
export interface ConversationTurn {
  id: string;                    // 轮次ID
  role: 'user' | 'assistant';    // 角色
  content: string;               // 内容
  timestamp: Date;               // 时间戳
  metadata?: Record<string, any>; // 元数据
}

// 提示词构建上下文
export interface PromptBuildContext {
  mode: ChatMode;                // 聊天模式
  userMessage: string;           // 用户消息
  conversationHistory: ConversationTurn[]; // 对话历史
  codeContext?: EnhancedCodeContext; // 代码上下文
  memories?: Memory[];           // 记忆
  toolHistory?: ToolUsage[];     // 工具使用历史
  guidelines?: Guideline[];      // 指导原则
  rules?: Rule[];               // 规则
  variables?: Record<string, any>; // 模板变量
  metadata?: Record<string, any>; // 元数据
}

// 增强的代码上下文
export interface EnhancedCodeContext {
  currentFile?: FileInfo;        // 当前文件
  selectedCode?: string;         // 选中代码
  workspaceFiles?: FileInfo[];   // 工作区文件
  recentFiles?: FileInfo[];      // 最近文件
  diagnostics?: Diagnostic[];    // 诊断信息
  gitInfo?: GitInfo;             // Git信息
}

// Git信息
export interface GitInfo {
  branch?: string;               // 当前分支
  commit?: string;               // 当前提交
  status?: string;               // 状态
  recentCommits?: GitCommit[];   // 最近提交
}

// Git提交
export interface GitCommit {
  hash: string;                  // 提交哈希
  message: string;               // 提交消息
  author: string;                // 作者
  date: Date;                    // 提交日期
}

// 文件信息
export interface FileInfo {
  path: string;                  // 文件路径
  content?: string;              // 文件内容
  language?: string;             // 编程语言
  size?: number;                 // 文件大小
  lastModified?: Date;           // 最后修改时间
}

// 记忆
export interface Memory {
  id: string;                    // 记忆ID
  content: string;               // 记忆内容
  type: MemoryType;              // 记忆类型
  relevance?: number;            // 相关性评分 (0-1)
  timestamp: Date;               // 创建时间
  metadata?: Record<string, any>; // 元数据
}

// 记忆类型
export enum MemoryType {
  FACT = 'fact',                 // 事实
  PREFERENCE = 'preference',     // 偏好
  CONTEXT = 'context',           // 上下文
  INSTRUCTION = 'instruction',   // 指令
  PATTERN = 'pattern'            // 模式
}

// 工具使用记录
export interface ToolUsage {
  id: string;                    // 使用ID
  toolName: string;              // 工具名称
  input: any;                    // 输入参数
  output?: any;                  // 输出结果
  success: boolean;              // 是否成功
  timestamp: Date;               // 使用时间
  duration?: number;             // 执行时长(ms)
  metadata?: Record<string, any>; // 元数据
}

// 指导原则
export interface Guideline {
  id: string;                    // 原则ID
  title: string;                 // 标题
  content: string;               // 内容
  category?: string;             // 分类
  priority?: number;             // 优先级
  scope?: 'global' | 'workspace' | 'project'; // 作用域
}

// 规则
export interface Rule {
  id: string;                    // 规则ID
  name: string;                  // 规则名称
  description?: string;          // 规则描述
  pattern?: string;              // 匹配模式
  action: string;                // 执行动作
  enabled: boolean;              // 是否启用
  priority?: number;             // 优先级
}

// 诊断信息
export interface Diagnostic {
  file: string;                  // 文件路径
  line: number;                  // 行号
  column: number;                // 列号
  severity: 'error' | 'warning' | 'info' | 'hint'; // 严重程度
  message: string;               // 消息
  source?: string;               // 来源
}

// 对话上下文接口
export interface ConversationContext {
  id: string;                    // 对话ID
  mode: ChatMode;                // 聊天模式
  turns: Turn[];                 // 对话轮次
  codeContext?: CodeContext;     // 代码上下文
  memories: AgentMemory[];       // 代理记忆
  activeTools: ToolType[];       // 激活的工具
  metadata?: Record<string, any>; // 元数据
}

// 流式事件接口
export interface StreamEvent {
  type: 'start' | 'chunk' | 'node' | 'tool' | 'end' | 'error';
  data: any;
  nodeType?: NodeType;
  timestamp: number;
}

// 工具执行结果接口
export interface ToolExecutionResult {
  success: boolean;
  result?: any;
  error?: string;
  metadata?: Record<string, any>;
}

// AI 模型接口
export interface AIModel {
  generateResponse(
    prompt: string,
    context: ConversationContext,
    config?: Partial<PromptConfig>
  ): AsyncGenerator<StreamEvent, void, unknown>;

  generateSuggestedQuestions(
    turns: Turn[],
    count?: number
  ): Promise<string[]>;
}

// 工具执行器接口
export interface ToolExecutor {
  execute(tool: string, input: unknown, context: ConversationContext): Promise<ToolExecutionResult>;
  canExecute(toolType: ToolType): boolean;
  getToolTypes(): ToolType[];
}

// 记忆管理器接口
export interface MemoryManager {
  saveMemory(memory: Omit<AgentMemory, 'id' | 'timestamp'>): Promise<AgentMemory>;
  getMemories(state?: AgentMemory['state']): Promise<AgentMemory[]>;
  updateMemoryState(id: string, state: AgentMemory['state'], content?: string): Promise<void>;
  deleteMemory(id: string): Promise<void>;
}